From the package's GitHub repository:

"These four color maps are designed in such a way that they will analytically be perfectly perceptually-uniform, both in regular form and also when converted to black-and-white. They are also designed to be perceived by readers with the most common form of color blindness."

• Viridis is now the default color map for Matplotlib, a key Python plotting library.
• The viridisLite package is a simpler version of the viridis package (and requires fewer dependencies).
• Several of the packages we'll look at today use Viridis as the default color map.

Here is an example of a hexbin graph of random values that uses the Viridis color map:

library(viridisLite); library(hexbin)
dat <- data.frame(x = rnorm(10000), y = rnorm(10000))
ggplot(dat, aes(x = x, y = y)) + geom_hex() + coord_fixed() +
  scale_fill_gradientn(colours = viridis(256, option = "D"))

The option argument allows you to pick between four color maps: Magma, Inferno, Plasma, and Viridis. Here is the code to visualize each of those (plot on next page):

library(gridExtra)
ex_plot <- ggplot(dat, aes(x = x, y = y)) + geom_hex() + coord_fixed()
magma_plot <- ex_plot + 
  scale_fill_gradientn(colours = viridis(256, option = "A"))
inferno_plot <- ex_plot + 
  scale_fill_gradientn(colours = viridis(256, option = "B"))
plasma_plot <- ex_plot + 
  scale_fill_gradientn(colours = viridis(256, option = "C"))
viridis_plot <- ex_plot + 
  scale_fill_gradientn(colours = viridis(256, option = "D"))
grid.arrange(magma_plot, inferno_plot, plasma_plot, viridis_plot, ncol = 2)

Very smart people have been working on creating interactive graphics in R for a long time. So far, nothing coded in R has taken off in a big way.

JavaScript has developed a number of interactive graphics libraries that can be for documents viewed in a web browser. There is now a series of R packages that allow you to create plots from these JavaScript libraries from within R.

There is a website with much more on these htmlWidgets at http://www.htmlwidgets.org.

Some of the packages availabe to help you create interactive graphics from R using JavaScript graphics libraries:

• leaflet: Mapping (we'll cover this next week)
• dygraphs: Time series
• plotly: A variety of plots, including maps
• rbokeh: A variety of plots, including maps
• networkD3: Network data
• d3heatmap: Heatmaps
• DT: Data tables
• DiagrammeR: Diagrams and flowcharts

These packages can be used to make some pretty cool interactive visualizations for HTML output from R Markdown or Shiny (you can also render any of theme in RStudio).

There are, however, a few limitations:

• Written by different people. The different packages have different styles as well as different interfaces. Learning how to use one package may not help you much with other of these packages.
• Many are still in development, often in early development.

From the package documentation:

"Easily translate ggplot2 graphs to an interactive web-based version and / or create custom web-based visualizations directly from R."

• Like many of the packages today, draws on functionality external to R, but within a package that allows you to work exclusively within R.
• Allows you to create interactive graphs from R. Some of the functions extend the ggplot2 code you've learned.
• Interactivity will only work within RStudio or on documents rendered to HTML.

The plotly package allows an interface to let you work with plotly.js code directly using R code.

plotly.js is an open source library for creating interactive graphs in JavaScript. This JavaScript library is built on d3.js (Data-Driven Documents), which is a key driver in interactive web-based data graphics today.

There are two main ways of create plots within plotly:

• Use one of the functions to create a customized interactive graphic:
  • plot_ly: Workhorse of plotly, renders most non-map types of graphs
  • plot_geo, plot_mapbax: Specific functions for creating plotly maps.
• Create a ggplot object and then convert it to a plotly object using the ggplotly function.

library(faraway); data(worldcup)
library(plotly)
plot_ly(worldcup, type = "scatter", x = ~ Time, y = ~ Shots)

Just like with ggplot2, the mappings you need depend on the type of plot you are creating.

For example, scatterplots (type = "scatter") need x and y defined, while a surface plot (type = "surface") can be created with a single vector of elevation (we'll see an example in a few slides).

The help file for plot_ly includes a link with more documentation on the types of plots that can be made and the required mappings for each.

plot_ly(worldcup, type = "scatter", x = ~ Time, y = ~ Shots,
        color = ~ Position)

The plotly package is designed so you can pipe data into plot_ly and add elements by piping into add_* functions (this idea is similar to adding elements to a ggplot object with +).

worldcup %>%
  plot_ly(x = ~ Time, y = ~ Shots, color = ~ Position) %>%
  add_markers()

Some of the add_* functions include:

• add_markers
• add_lines
• add_paths
• add_polygons
• add_segments
• add_histogram

If you pipe to the rangeslider function, it allows the viewer to zoom in on part of the x range. (This can be particularly nice for time series.)

You should have a dataset available through your R session named USAccDeaths. This gives a montly county of accidental deaths in the US for 1973 to 1978. This code will plot it and add a range slider on the lower x-axis.

plot_ly(x = time(USAccDeaths), y = USAccDeaths) %>% 
  add_lines() %>% rangeslider()

For a 3-D scatterplot, add a mapping to the z variable:

worldcup %>%
  plot_ly(x = ~ Time, y = ~ Shots, z = ~ Passes,
          color = ~ Position, size = I(4)) %>%
  add_markers()

The volcano data comes with R and is in a matrix format. Each value gives the elevation for a particular pair of x- and y-coordinates.

dim(volcano)

## [1] 87 61

volcano[1:4, 1:4]

##      [,1] [,2] [,3] [,4]
## [1,]  100  100  101  101
## [2,]  101  101  102  102
## [3,]  102  102  103  103
## [4,]  103  103  104  104

plot_ly(z = ~ volcano, type = "surface")

Mapping with plotly can build on some data that comes with base R or other packages you've likely added (or can add easily, as with the map_data function from ggplot2). For example, we can map state capitals and cities with > 40,000 people using data in the us.cities dataframe in the maps package:

head(maps::us.cities, 3)

##         name country.etc    pop   lat    long capital
## 1 Abilene TX          TX 113888 32.45  -99.74       0
## 2   Akron OH          OH 206634 41.08  -81.52       0
## 3 Alameda CA          CA  70069 37.77 -122.26       0

Here is code you can use to map all of these cities on a US map:

ggplot2::map_data("world", "usa") %>%
   group_by(group) %>% filter(-125 < long & long < -60 &
                                25 < lat & lat < 52) %>%
   plot_ly(x = ~long, y = ~lat) %>%
   add_polygons(hoverinfo = "none") %>%
   add_markers(text = ~paste(name, "<br />", pop), hoverinfo = "text",
               alpha = 0.25,
     data = filter(maps::us.cities, -125 < long & long < -60 &
                     25 < lat & lat < 52)) %>%
   layout(showlegend = FALSE)

library(choroplethr)
data(df_pop_state)
state_choropleth(df_pop_state)

us_map <- list(scope = 'usa',
  projection = list(type = 'albers usa'),
  lakecolor = toRGB('white'))
plot_geo() %>%
   add_trace(z = df_pop_state$value[df_pop_state$region != 
                                        "district of columbia"],
             text = state.name, locations = state.abb,
             locationmode = 'USA-states') %>%
  add_markers(x = state.center[["x"]], y = state.center[["y"]], 
    size = I(2), symbol = I(8), color = I("white"), hoverinfo = "none") %>%
  layout(geo = us_map)

The other way to create a plotly graph is to first create a ggplot object and then transform it into an interactive graphic using the ggplotly function.

The following code can be used to plot Time versus Shots for the World Cup date:

shots_vs_time <- worldcup %>%
  mutate(Name = rownames(worldcup)) %>%
  filter(Team %in% c("Netherlands", "Germany", "Spain", "Uruguay")) %>%
  ggplot(aes(x = Time, y = Shots, color = Position, group = Name)) + 
  geom_point() + 
  facet_wrap(~ Team)
shots_vs_time

ggplotly(shots_vs_time)

With R, not only can you pull things from another website using an API, you can also upload or submit things.

There is a function in the plotly library, plotly_POST, that lets you post a plot you create in R to https://plot.ly.

You need a plot.ly account to do that, but there are free accounts available.

The creator of the R plotly package has written a bookdown book on the package that you can read here. It provides extensive details and examples for using plotly.

Getting Started with D3 by Mike Dewar (a short book on D3 in JavaScript) is available for free here.

The rbokeh package provides an R interface to a Python interactive visualization library, Bokeh.

There is a website with many more details on using the rbokeh package: https://hafen.github.io/rbokeh/

You can find out more about the original Python library, Bokeh, at http://bokeh.pydata.org/en/latest/.

library(rbokeh)
figure(width = 600, height = 300) %>%
  ly_points(Time, Shots, data = worldcup,
    color = Position, hover = list(Time, Shots))

This package can also be used to create interactive maps. For example, the following dataset has data on Oregon climate stations, including locations:

orstationc <- read.csv(paste0("http://geog.uoregon.edu/bartlein/",
                              "old_courses/geog414s05/data/orstationc.csv"))
head(orstationc, 3)

##   station    lat      lon elev tjan tjul tann pjan pjul pann  idnum
## 1     ANT 44.917 -120.717  846  0.0 20.2  9.6   41    9  322 350197
## 2     ARL 45.717 -120.200   96  0.9 24.6 12.5   40    6  228 350265
## 3     ASH 42.217 -122.717  543  3.1 20.8 11.1   70    7  480 350304
##                  Name
## 1 ANTELOPE 1 N USA-OR
## 2    ARLINGTON USA-OR
## 3  ASHLAND 1 N USA-OR

You can use the following code to create an interactive map of these climate stations:

gmap(lat = 44.1, lng = -120.767, zoom = 6,
     width = 700, height = 600) %>%
  ly_points(lon, lat, data = orstationc, alpha = 0.8, col = "red",
    hover = c(station, Name, elev, tann))

The dygraphs package lets you create interactive time series plots from R using the dygraphs JavaScript library.

The main function syntax is fairly straightforward. Like many of these packages, it allows piping.

There is a website with more information on using dygraphs available at http://rstudio.github.io/dygraphs/index.html.

For example, here is the code to plot monthly deaths from lung diseases in the UK in the 1970s.

library(dygraphs)
lungDeaths <- cbind(mdeaths, fdeaths)
dygraph(lungDeaths) %>%
  dySeries("mdeaths", label = "Male") %>%
  dySeries("fdeaths", label = "Female")

For example, here is the code to plot monthly deaths from lung diseases in the UK in the 1970s.

The DT package provides a way to create interactive tables in R using the JavaScript DataTables library.

We've already seen some examples of this output in some of the Shiny apps I showed last week. You can also use this package to include interactive tables in R Markdown documents you plan to render to HTML.

There is a website with more information on this package at http://rstudio.github.io/DT/.

library(DT)
datatable(worldcup)

If you find a JavaScript visualization library and would like to create bindings to R, you can create your own package for a new htmlWidget.

There is advice on creating your own widget for R available at http://www.htmlwidgets.org/develop_intro.html.